home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / gdevepsn.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  14.4 KB  |  501 lines
  1. /* Copyright (C) 1989-1994, 1998 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: gdevepsn.c,v 1.2 2000/09/19 19:00:13 lpd Exp $*/
  20. /*
  21.  * Epson (and similar) dot-matrix printer driver for Ghostscript.
  22.  *
  23.  * Four devices are defined here: 'epson', 'eps9mid', 'eps9high', and 'ibmpro'.
  24.  * The 'epson' device is the generic device, for 9-pin and 24-pin printers.
  25.  * 'eps9high' is a special mode for 9-pin printers where scan lines are
  26.  * interleaved in multiple passes to produce high vertical resolution at
  27.  * the expense of several passes of the print head.  'eps9mid' is a special
  28.  * mode for 9 pin printers too, scan lines are interleaved but with next
  29.  * vertical line. 'ibmpro' is for the IBM ProPrinter, which has slightly 
  30.  * (but only slightly) different control codes.
  31.  *
  32.  * Thanks to:
  33.  *    David Wexelblat (dwex@mtgzfs3.att.com) for the 'eps9high' code;
  34.  *    Guenther Thomsen (thomsen@cs.tu-berlin.de) for the 'eps9mid' code;
  35.  *    James W. Birdsall (jwbirdsa@picarefy.picarefy.com) for the
  36.  *      'ibmpro' modifications;
  37.  *    Russell J. Lang (rjl@aladdin.com) for the 180x60 and 240x180 dpi
  38.  *      enhancements.
  39.  */
  40. #include "gdevprn.h"
  41.  
  42. /*
  43.  * Define whether the printer is archaic -- so old that it doesn't
  44.  * support settable tabs, pitch, or left margin.  (This should be a
  45.  * run-time property....)  Note: the IBM ProPrinter is archaic.
  46.  */
  47. /*#define ARCHAIC 1*/
  48.  
  49. /*
  50.  * Define whether the printer is a Panasonic 9-pin printer,
  51.  * which sometimes doesn't recognize a horizontal tab command
  52.  * when a line contains a lot of graphics commands,
  53.  * requiring a "backspace, space" sequence before a tab.
  54.  */
  55. /*#define TAB_HICCUP 1*/
  56.  
  57. /*
  58.  * Define the minimum distance for which it's worth converting white space
  59.  * into a tab.  This can be specified in pixels (to save transmission time),
  60.  * in tenths of an inch (for printers where tabs provoke actual head motion),
  61.  * or both.  The distance must meet BOTH criteria for the driver to tab,
  62.  * so an irrelevant criterion should be set to 0 rather than infinite.
  63.  */
  64. #define MIN_TAB_PIXELS 10
  65. #define MIN_TAB_10THS 15
  66.  
  67. /*
  68.  * Valid values for X_DPI:
  69.  *
  70.  *    For 9-pin printers: 60, 120, 240
  71.  *    For 24-pin printers: 60, 120, 180, 240, 360
  72.  *
  73.  * The value specified at compile time is the default value used if the
  74.  * user does not specify a resolution at runtime.
  75.  */
  76. #ifndef X_DPI
  77. #  define X_DPI 240
  78. #endif
  79.  
  80. /*
  81.  * For Y_DPI, a given printer will support a base resolution of 60 or 72;
  82.  * check the printer manual.  The Y_DPI value must be a multiple of this
  83.  * base resolution.  Valid values for Y_DPI:
  84.  *
  85.  *    For 9-pin printers: 1*base_res
  86.  *    For 24-pin printers: 1*base_res, 3*base_res
  87.  *
  88.  * The value specified at compile time is the default value used if the
  89.  * user does not specify a resolution at runtime.
  90.  */
  91.  
  92. #ifndef Y_BASERES
  93. #  define Y_BASERES 72
  94. #endif
  95. #ifndef Y_DPI
  96. #  define Y_DPI (1*Y_BASERES)
  97. #endif
  98.  
  99. /* The device descriptors */
  100. private dev_proc_print_page(epson_print_page);
  101. private dev_proc_print_page(eps9mid_print_page); 
  102. private dev_proc_print_page(eps9high_print_page);
  103. private dev_proc_print_page(ibmpro_print_page);
  104.  
  105. /* Standard Epson device */
  106. gx_device_printer far_data gs_epson_device =
  107.   prn_device(prn_std_procs, "epson",
  108.     DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
  109.     X_DPI, Y_DPI,
  110.     0.2, 0.0, 0.0, 0.0,            /* margins */
  111.     1, epson_print_page);
  112.  
  113. /* Mid-res (interleaved, 1 pass per line) 9-pin device */
  114. gx_device_printer far_data gs_eps9mid_device = 
  115.   prn_device(prn_std_procs, "eps9mid",
  116.     DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
  117.     X_DPI, 3*Y_BASERES,
  118.     0.2, 0.0, 0, 0.0,            /* margins */
  119.     1, eps9mid_print_page);
  120.  
  121.  
  122. /* High-res (interleaved) 9-pin device */
  123. gx_device_printer far_data gs_eps9high_device = 
  124.   prn_device(prn_std_procs, "eps9high",
  125.     DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
  126.     X_DPI, 3*Y_BASERES,
  127.     0.2, 0.0, 0.0, 0.0,            /* margins */
  128.     1, eps9high_print_page);
  129.  
  130. /* IBM ProPrinter device */
  131. gx_device_printer far_data gs_ibmpro_device =
  132.   prn_device(prn_std_procs, "ibmpro",
  133.     DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
  134.     X_DPI, Y_DPI,
  135.     0.2, 0.0, 0.0, 0.0,            /* margins */
  136.     1, ibmpro_print_page);
  137.  
  138. /* ------ Driver procedures ------ */
  139.  
  140. /* Forward references */
  141. private void eps_output_run(P6(byte *, int, int, char, FILE *, int));
  142.  
  143. /* Send the page to the printer. */
  144. #define DD 0x40                /* double density flag */
  145. private int
  146. eps_print_page(gx_device_printer *pdev, FILE *prn_stream, int y_9pin_high,
  147.   const char *init_string, int init_length, const char *end_string,
  148.   int archaic, int tab_hiccup)
  149. {    
  150.     static const char graphics_modes_9[5] =
  151.     {    
  152.     -1, 0 /*60*/, 1    /*120*/, 7 /*180*/, DD+3 /*240*/
  153.     };
  154.  
  155.     static const char graphics_modes_24[7] =
  156.     {    
  157.         -1, 32 /*60*/, 33 /*120*/, 39 /*180*/,
  158.     DD+35 /*240*/, -1, DD+40 /*360*/
  159.     };
  160.  
  161.     int y_24pin = (y_9pin_high ? 0 : pdev->y_pixels_per_inch > 72);
  162.     int in_y_mult = ((y_24pin | y_9pin_high) ? 3 : 1);
  163.     int line_size = gdev_mem_bytes_per_scan_line((gx_device *)pdev);
  164.     /* Note that in_size is a multiple of 8. */
  165.     int in_size = line_size * (8 * in_y_mult);
  166.     byte *buf1 = (byte *)gs_malloc(in_size, 1, "eps_print_page(buf1)");
  167.     byte *buf2 = (byte *)gs_malloc(in_size, 1, "eps_print_page(buf2)");
  168.     byte *in = buf1;
  169.     byte *out = buf2;
  170.     int out_y_mult = (y_24pin ? 3 : 1);
  171.     int x_dpi = pdev->x_pixels_per_inch;
  172.     char start_graphics =
  173.         (y_24pin ? graphics_modes_24 : graphics_modes_9)[x_dpi / 60];
  174.     int first_pass = (start_graphics & DD ? 1 : 0);
  175.     int last_pass = first_pass * (y_9pin_high == 2 ? 1 : 2); 
  176.     int y_passes = (y_9pin_high ? 3 : 1);
  177.     int dots_per_space = x_dpi / 10;    /* pica space = 1/10" */
  178.     int bytes_per_space = dots_per_space * out_y_mult;
  179.     int tab_min_pixels = x_dpi * MIN_TAB_10THS / 10;
  180.     int skip = 0, lnum = 0, pass, ypass;
  181.  
  182.     /* Check allocations */
  183.     if ( buf1 == 0 || buf2 == 0 )
  184.     {    if ( buf1 ) 
  185.           gs_free((char *)buf1, in_size, 1, "eps_print_page(buf1)");
  186.         if ( buf2 ) 
  187.           gs_free((char *)buf2, in_size, 1, "eps_print_page(buf2)");
  188.         return_error(gs_error_VMerror);
  189.     }
  190.  
  191.     /* Initialize the printer and reset the margins. */
  192.     fwrite(init_string, 1, init_length, prn_stream);
  193.     if ( init_string[init_length - 1] == 'Q' )
  194.         fputc((int)(pdev->width / pdev->x_pixels_per_inch * 10) + 2,
  195.               prn_stream);
  196.  
  197.     /* Calculate the minimum tab distance. */
  198.     if ( tab_min_pixels < max(MIN_TAB_PIXELS, 3) )
  199.         tab_min_pixels = max(MIN_TAB_PIXELS, 3);
  200.     tab_min_pixels -= tab_min_pixels % 3;    /* simplify life */
  201.  
  202.     /* Print lines of graphics */
  203.     while ( lnum < pdev->height )
  204.     {    
  205.         byte *in_data;
  206.         byte *inp;
  207.         byte *in_end;
  208.         byte *out_end;
  209.         byte *out_blk;
  210.         register byte *outp;
  211.         int lcnt;
  212.  
  213.         /* Copy 1 scan line and test for all zero. */
  214.         gdev_prn_get_bits(pdev, lnum, in, &in_data);
  215.         if ( in_data[0] == 0 &&
  216.              !memcmp((char *)in_data, (char *)in_data + 1, line_size - 1)
  217.            )
  218.             {    
  219.             lnum++;
  220.             skip += 3 / in_y_mult;
  221.             continue;
  222.         }
  223.  
  224.         /* Vertical tab to the appropriate position. */
  225.         while ( skip > 255 )
  226.         {    
  227.             fputs("\033J\377", prn_stream);
  228.             skip -= 255;
  229.         }
  230.         if ( skip )
  231.         {
  232.             fprintf(prn_stream, "\033J%c", skip);
  233.         }
  234.  
  235.         /* Copy the the scan lines. */
  236.             lcnt = gdev_prn_copy_scan_lines(pdev, lnum, in, in_size);
  237.         if ( lcnt < 8 * in_y_mult )
  238.         {    /* Pad with lines of zeros. */
  239.             memset(in + lcnt * line_size, 0,
  240.                    in_size - lcnt * line_size);
  241.         }
  242.  
  243.         if ( y_9pin_high == 2 ) 
  244.         {    /* Force printing of every dot in one pass */
  245.             /* by reducing vertical resolution */
  246.                 /* (ORing with the next line of data). */
  247.                 /* This is necessary because some Epson compatibles */
  248.             /* can't print neighboring dots. */
  249.             int i;
  250.             for ( i = 0; i < line_size * in_y_mult; ++i )
  251.                 in_data[i] |= in_data[i + line_size];
  252.         }
  253.  
  254.         if ( y_9pin_high )
  255.         {    /* Shuffle the scan lines */
  256.             byte *p;
  257.             int i;
  258.             static const char index[] =
  259.             {  0,  8, 16,  1,  9, 17,  
  260.                2, 10, 18,  3, 11, 19,
  261.                4, 12, 20,  5, 13, 21,
  262.                6, 14, 22,  7, 15, 23
  263.             };
  264.  
  265.             for ( i = 0; i < 24; i++ )
  266.             {
  267.                 memcpy(out+(index[i]*line_size),
  268.                        in+(i*line_size), line_size);
  269.             }
  270.             p = in;
  271.             in = out;
  272.             out = p;
  273.         }
  274.  
  275.     for ( ypass = 0; ypass < y_passes; ypass++ )
  276.     {
  277.         for ( pass = first_pass; pass <= last_pass; pass++ )
  278.         {
  279.         /* We have to 'transpose' blocks of 8 pixels x 8 lines, */
  280.         /* because that's how the printer wants the data. */
  281.         /* If we are in a 24-pin mode, we have to transpose */
  282.         /* groups of 3 lines at a time. */
  283.  
  284.         if ( pass == first_pass )
  285.         {
  286.             out_end = out;
  287.             inp = in;
  288.             in_end = inp + line_size;
  289.     
  290.             if ( y_24pin )
  291.                     { 
  292.                 for ( ; inp < in_end; inp++, out_end += 24 )
  293.                 { 
  294.                             gdev_prn_transpose_8x8(inp, line_size, out_end, 3);
  295.                             gdev_prn_transpose_8x8(inp + line_size * 8, 
  296.                                line_size, out_end + 1, 3);
  297.                             gdev_prn_transpose_8x8(inp + line_size * 16, 
  298.                                line_size, out_end + 2, 3);
  299.             }
  300.             /* Remove trailing 0s. */
  301.             while ( out_end > out && out_end[-1] == 0 &&
  302.                        out_end[-2] == 0 && out_end[-3] == 0)
  303.             {
  304.                      out_end -= 3;
  305.             }
  306.                     }
  307.             else
  308.                     { 
  309.                 for ( ; inp < in_end; inp++, out_end += 8 )
  310.                 { 
  311.                         gdev_prn_transpose_8x8(inp + (ypass * 8*line_size), 
  312.                                line_size, out_end, 1);
  313.                 }
  314.             /* Remove trailing 0s. */
  315.             while ( out_end > out && out_end[-1] == 0 )
  316.                 {
  317.                        out_end--;
  318.             }
  319.                     }
  320.         }
  321.  
  322.         for ( out_blk = outp = out; outp < out_end; )
  323.             { 
  324.                  /* Skip a run of leading 0s.  At least */
  325.                     /* tab_min_pixels are needed to make tabbing */
  326.                 /* worth it.  We do everything by 3's to */
  327.                 /* avoid having to make different cases */
  328.                 /* for 9- and 24-pin. */
  329.            if ( !archaic &&
  330.             *outp == 0 && out_end - outp >= tab_min_pixels &&
  331.             (outp[1] | outp[2]) == 0 &&
  332.             !memcmp((char *)outp, (char *)outp + 3,
  333.                 tab_min_pixels - 3)
  334.               )
  335.                     {
  336.                 byte *zp = outp;
  337.             int tpos;
  338.             byte *newp;
  339.            
  340.             outp += tab_min_pixels;
  341.                 while ( outp + 3 <= out_end && 
  342.                          *outp == 0 &&
  343.                     outp[1] == 0 && outp[2] == 0 )
  344.                 {
  345.                 outp += 3;
  346.                 }
  347.             tpos = (outp - out) / bytes_per_space;
  348.             newp = out + tpos * bytes_per_space;
  349.             if ( newp > zp + 10 )
  350.                 { 
  351.                     /* Output preceding bit data.*/
  352.                        if ( zp > out_blk )    
  353.                     {
  354.                     /* only false at beginning of line */
  355.                      eps_output_run(out_blk, (int)(zp - out_blk),
  356.                                    out_y_mult, start_graphics, 
  357.                            prn_stream,
  358.                            (y_9pin_high == 2 ?
  359.                             (1 + ypass) & 1 : pass));
  360.                 }
  361.                 /* Tab over to the appropriate position. */
  362.                 if ( tab_hiccup )
  363.                   fputs("\010 ", prn_stream); /* bksp, space */
  364.                 /* The following statement is broken up */
  365.                 /* to work around a bug in emx/gcc. */
  366.                 fprintf(prn_stream, "\033D%c", tpos);
  367.                 fputc(0, prn_stream);
  368.                 fputc('\t', prn_stream);
  369.                 out_blk = outp = newp;
  370.             }
  371.             }
  372.             else
  373.             {
  374.                 outp += out_y_mult;
  375.             }
  376.             }
  377.         if ( outp > out_blk )
  378.         {
  379.             eps_output_run(out_blk, (int)(outp - out_blk),
  380.                        out_y_mult, start_graphics,
  381.                    prn_stream,
  382.                    (y_9pin_high == 2 ? (1 + ypass) & 1 : pass));
  383.         }
  384.  
  385.         fputc('\r', prn_stream);
  386.         }
  387.         if ( ypass < y_passes - 1 )
  388.         fputs("\033J\001", prn_stream);
  389.     }
  390.     skip = 24 - y_passes + 1;        /* no skip on last Y pass */
  391.     lnum += 8 * in_y_mult;
  392.     }
  393.  
  394.     /* Eject the page and reinitialize the printer */
  395.     fputs(end_string, prn_stream);
  396.     fflush(prn_stream);
  397.  
  398.     gs_free((char *)buf2, in_size, 1, "eps_print_page(buf2)");
  399.     gs_free((char *)buf1, in_size, 1, "eps_print_page(buf1)");
  400.     return 0;
  401. }
  402.  
  403. /* Output a single graphics command. */
  404. /* pass=0 for all columns, 1 for even columns, 2 for odd columns. */
  405. private void
  406. eps_output_run(byte *data, int count, int y_mult,
  407.   char start_graphics, FILE *prn_stream, int pass)
  408. {    
  409.     int xcount = count / y_mult;
  410.  
  411.     fputc(033, prn_stream);
  412.     if ( !(start_graphics & ~3) )
  413.     {    
  414.         fputc("KLYZ"[start_graphics], prn_stream);
  415.     }
  416.     else
  417.     {    
  418.         fputc('*', prn_stream);
  419.         fputc(start_graphics & ~DD, prn_stream);
  420.     }
  421.     fputc(xcount & 0xff, prn_stream);
  422.     fputc(xcount >> 8, prn_stream);
  423.     if ( !pass )
  424.     {
  425.         fwrite(data, 1, count, prn_stream);
  426.     }
  427.     else
  428.     {    
  429.         /* Only write every other column of y_mult bytes. */
  430.         int which = pass;
  431.         register byte *dp = data;
  432.         register int i, j;
  433.  
  434.         for ( i = 0; i < xcount; i++, which++ )
  435.         {
  436.             for ( j = 0; j < y_mult; j++, dp++ )
  437.             {
  438.                 putc(((which & 1) ? *dp : 0), prn_stream);
  439.             }
  440.         }
  441.     }
  442. }
  443.  
  444. /* The print_page procedures are here, to avoid a forward reference. */
  445. #ifndef ARCHAIC
  446. #  define ARCHAIC 0
  447. #endif
  448. #ifndef TAB_HICCUP
  449. #  define TAB_HICCUP 0
  450. #endif
  451.  
  452. #define ESC 0x1b
  453. private const char eps_init_string[] = {
  454. #if ARCHAIC
  455.     ESC, '@', 022 /*^R*/, ESC, 'Q'
  456. #else
  457.     ESC, '@', ESC, 'P', ESC, 'l', 0, '\r', ESC, 'Q'
  458. #endif
  459. };
  460.  
  461. private int
  462. epson_print_page(gx_device_printer *pdev, FILE *prn_stream)
  463. {
  464.     return eps_print_page(pdev, prn_stream, 0, eps_init_string,
  465.                   sizeof(eps_init_string), "\f\033@",
  466.                   ARCHAIC, TAB_HICCUP);
  467. }
  468.  
  469. private int
  470. eps9high_print_page(gx_device_printer *pdev, FILE *prn_stream)
  471. {
  472.     return eps_print_page(pdev, prn_stream, 1, eps_init_string,
  473.                   sizeof(eps_init_string), "\f\033@",
  474.                   ARCHAIC, TAB_HICCUP);
  475. }
  476.  
  477. private int
  478. eps9mid_print_page(gx_device_printer *pdev, FILE *prn_stream)
  479. {
  480.     return eps_print_page(pdev, prn_stream, 2, eps_init_string,
  481.                   sizeof(eps_init_string), "\f\033@", 
  482.                   ARCHAIC, TAB_HICCUP);
  483. }
  484.  
  485. private int
  486. ibmpro_print_page(gx_device_printer *pdev, FILE *prn_stream)
  487. {
  488.     /*
  489.      * IBM Proprinter Guide to Operations, p. 4-5: "DC1: Select Printer: Sets
  490.      * the printer to accept data from your computer."  Prevents printer from
  491.      * interpreting first characters as literal text.
  492.      */
  493. #define DC1 0x11
  494.     static const char ibmpro_init_string[] = {
  495.         DC1, ESC, '3', 0x30
  496.     };
  497. #undef DC1
  498.     return eps_print_page(pdev, prn_stream, 0, ibmpro_init_string,
  499.                   sizeof(ibmpro_init_string), "\f", 1, 0);
  500. }
  501.